/**
 * 图像处理工具类
 */
const ImageProcessor = {
  // 图像处理模式
  MODES: {
    ORIGINAL: 'original',    // 原图
    ENHANCE: 'enhance',      // 增强
    SHARPEN: 'sharpen',      // 锐化
    BW: 'bw'                 // 黑白
  },
  
  /**
   * 增强文档图像
   * @param {String|Object} imagePath 图片路径或图像信息对象
   * @returns {Promise} 返回处理后的图片路径
   */
  enhanceDocument: function(imagePath) {
    // 确保imagePath是字符串
    if (typeof imagePath === 'object' && imagePath.imagePath) {
      imagePath = imagePath.imagePath;
    }
    
    console.log('开始增强文档图像:', imagePath);
    
    // 调用applyImageEffect函数应用增强效果
    return this.applyImageEffect(imagePath, this.MODES.ENHANCE);
  },
  /**
   * 检测文档边缘
   * @param {String} imagePath 图片路径
   * @returns {Promise} 返回检测到的边缘点和原始图片信息
   */
  detectEdges: function(imagePath) {
    return new Promise((resolve, reject) => {
      console.log('开始检测文档边缘:', imagePath);
      
      // 确保imagePath是字符串
      if (typeof imagePath !== 'string') {
        console.error('图片路径必须是字符串:', imagePath);
        reject(new Error('图片路径必须是字符串'));
        return;
      }
      
      // 获取图片信息
      wx.getImageInfo({
        src: imagePath,
        success: (imageInfo) => {
          console.log('获取图片信息成功:', imageInfo.width, imageInfo.height);
          
          // 在实际应用中，这里应该使用更复杂的算法检测边缘
          // 简化版本中，我们假设文档占据图片的大部分区域，并稍微缩小边缘
          const margin = 0.1; // 边缘缩进比例
          const width = imageInfo.width;
          const height = imageInfo.height;
          
          // 计算默认的四个角点（顺时针：左上、右上、右下、左下）
          const corners = [
            { x: width * margin, y: height * margin },             // 左上
            { x: width * (1 - margin), y: height * margin },       // 右上
            { x: width * (1 - margin), y: height * (1 - margin) }, // 右下
            { x: width * margin, y: height * (1 - margin) }        // 左下
          ];
          
          resolve({
            corners: corners,
            imageInfo: imageInfo,
            imagePath: imagePath
          });
        },
        fail: (err) => {
          console.error('获取图片信息失败:', err);
          reject(err);
        }
      });
    });
  },
  
  /**
   * 应用透视校正
   * @param {String} imagePath 图片路径
   * @param {Array} corners 四个角点坐标
   * @returns {Promise} 返回处理后的图片路径
   */
  applyPerspectiveCorrection: function(imagePath, corners) {
    return new Promise((resolve, reject) => {
      try {
        console.log('开始应用透视校正:', imagePath);
        
        // 确保corners是有效的数组
        if (!corners || !Array.isArray(corners) || corners.length !== 4) {
          console.warn('无效的角点坐标，使用默认值');
          // 使用默认角点
          corners = [
            { x: 50, y: 50 },             // 左上
            { x: 550, y: 50 },            // 右上
            { x: 550, y: 750 },           // 右下
            { x: 50, y: 750 }             // 左下
          ];
        }
        
        console.log('角点坐标:', corners);
        
        // 创建临时文件路径
        const tempFilePath = `${wx.env.USER_DATA_PATH}/corrected_${Date.now()}.jpg`;
        
        // 获取图片信息
        wx.getImageInfo({
          src: imagePath,
          success: (imageInfo) => {
            console.log('获取图片信息成功:', imageInfo.width, imageInfo.height);
            
            // 创建canvas上下文
            const ctx = wx.createCanvasContext('imageProcessCanvas');
            
            // 设置canvas尺寸
            const canvasWidth = imageInfo.width;
            const canvasHeight = imageInfo.height;
            
            // 清空canvas
            ctx.clearRect(0, 0, canvasWidth, canvasHeight);
            ctx.fillStyle = '#FFFFFF';
            ctx.fillRect(0, 0, canvasWidth, canvasHeight);
            
            // 绘制原始图像
            ctx.drawImage(imagePath, 0, 0, canvasWidth, canvasHeight);
            
            // 绘制边缘线和角点，帮助用户查看校正效果
            ctx.beginPath();
            ctx.moveTo(corners[0].x, corners[0].y);
            ctx.lineTo(corners[1].x, corners[1].y);
            ctx.lineTo(corners[2].x, corners[2].y);
            ctx.lineTo(corners[3].x, corners[3].y);
            ctx.closePath();
            ctx.strokeStyle = '#FF0000';
            ctx.lineWidth = 2;
            ctx.stroke();
            
            // 绘制角点
            const drawCorner = (x, y) => {
              ctx.beginPath();
              ctx.arc(x, y, 5, 0, 2 * Math.PI);
              ctx.fillStyle = '#FF0000';
              ctx.fill();
            };
            
            corners.forEach(corner => {
              drawCorner(corner.x, corner.y);
            });
            
            // 应用透视校正（在实际应用中，这里应该使用更复杂的算法）
            // 在简化版本中，我们只是裁剪出四边形区域
            ctx.draw(false, () => {
              // 导出处理后的图像
              wx.canvasToTempFilePath({
                canvasId: 'imageProcessCanvas',
                x: Math.min(corners[0].x, corners[3].x),
                y: Math.min(corners[0].y, corners[1].y),
                width: Math.max(corners[1].x, corners[2].x) - Math.min(corners[0].x, corners[3].x),
                height: Math.max(corners[3].y, corners[2].y) - Math.min(corners[0].y, corners[1].y),
                destWidth: Math.max(corners[1].x, corners[2].x) - Math.min(corners[0].x, corners[3].x),
                destHeight: Math.max(corners[3].y, corners[2].y) - Math.min(corners[0].y, corners[1].y),
                fileType: 'jpg',
                quality: 0.9,
                success: (res) => {
                  console.log('透视校正成功:', res.tempFilePath);
                  resolve(res.tempFilePath);
                },
                fail: (err) => {
                  console.error('导出校正图像失败:', err);
                  // 如果失败，返回原图
                  resolve(imagePath);
                }
              });
            });
          },
          fail: (err) => {
            console.error('获取图片信息失败:', err);
            // 如果失败，返回原图
            resolve(imagePath);
          }
        });
      } catch (err) {
        console.error('透视校正过程出错:', err);
        // 出错时返回原图
        resolve(imagePath);
      }
    });
  },
  
  /**
   * 应用图像处理效果
   * @param {String} imagePath 图片路径
   * @param {String} mode 处理模式 (original, enhance, sharpen, bw)
   * @returns {Promise} 返回处理后的图片路径
   */
  applyImageEffect: function(imagePath, mode) {
    return new Promise((resolve, reject) => {
      try {
        console.log(`开始应用图像效果: ${mode}`, imagePath);
        
        // 确保imagePath是字符串
        if (typeof imagePath !== 'string') {
          console.error('图片路径必须是字符串:', imagePath);
          reject(new Error('图片路径必须是字符串'));
          return;
        }
        
        // 如果是原图模式，直接返回原图
        if (mode === this.MODES.ORIGINAL) {
          console.log('使用原图模式，不进行处理');
          resolve(imagePath);
          return;
        }
        
        // 获取图片信息
        wx.getImageInfo({
          src: imagePath,
          success: (imageInfo) => {
            console.log('获取图片信息成功:', imageInfo.width, imageInfo.height);
            
            // 创建临时文件路径
            const tempFilePath = `${wx.env.USER_DATA_PATH}/${mode}_${Date.now()}.jpg`;
            
            // 创建canvas上下文
            const ctx = wx.createCanvasContext('imageProcessCanvas');
            
            // 设置canvas尺寸
            const canvasWidth = imageInfo.width;
            const canvasHeight = imageInfo.height;
            
            // 清空canvas
            ctx.clearRect(0, 0, canvasWidth, canvasHeight);
            
            // 绘制原始图像
            ctx.drawImage(imagePath, 0, 0, canvasWidth, canvasHeight);
            
            // 根据不同模式应用不同效果
            switch (mode) {
              case this.MODES.ENHANCE:
                // 增强模式：提高对比度和亮度
                ctx.globalCompositeOperation = 'source-over';
                ctx.globalAlpha = 0.2;
                ctx.fillStyle = '#FFFFFF';
                ctx.fillRect(0, 0, canvasWidth, canvasHeight);
                ctx.globalAlpha = 1.0;
                break;
                
              case this.MODES.SHARPEN:
                // 锐化模式：在微信小程序中无法直接实现锐化
                // 这里我们通过增加对比度来模拟锐化效果
                ctx.globalCompositeOperation = 'source-over';
                ctx.globalAlpha = 0.3;
                ctx.fillStyle = '#000000';
                ctx.fillRect(0, 0, canvasWidth, canvasHeight);
                ctx.globalAlpha = 1.3; // 增加对比度
                ctx.drawImage(imagePath, 0, 0, canvasWidth, canvasHeight);
                ctx.globalAlpha = 1.0;
                break;
                
              case this.MODES.BW:
                // 黑白模式：使用灰度滤镜
                ctx.filter = 'grayscale(100%)';
                ctx.drawImage(imagePath, 0, 0, canvasWidth, canvasHeight);
                break;
            }
            
            // 完成绘制
            ctx.draw(false, () => {
              // 导出处理后的图像
              wx.canvasToTempFilePath({
                canvasId: 'imageProcessCanvas',
                x: 0,
                y: 0,
                width: canvasWidth,
                height: canvasHeight,
                destWidth: canvasWidth,
                destHeight: canvasHeight,
                fileType: 'jpg',
                quality: 0.9,
                success: (res) => {
                  console.log(`${mode}效果应用成功:`, res.tempFilePath);
                  resolve(res.tempFilePath);
                },
                fail: (err) => {
                  console.error(`应用${mode}效果失败:`, err);
                  // 如果失败，返回原图
                  resolve(imagePath);
                }
              });
            });
          },
          fail: (err) => {
            console.error('获取图片信息失败:', err);
            // 如果失败，返回原图
            resolve(imagePath);
          }
        });
      } catch (err) {
        console.error(`应用${mode}效果过程出错:`, err);
        // 出错时返回原图
        resolve(imagePath);
      }
    });
  },
  
  /**
   * 批量应用图像效果
   * @param {Array} imagePaths 图片路径数组
   * @param {String} mode 处理模式
   * @returns {Promise} 返回处理后的图片路径数组
   */
  batchApplyEffect: function(imagePaths, mode) {
    console.log(`开始批量应用${mode}效果，图片数量:`, imagePaths.length);
    
    const promises = imagePaths.map(path => this.applyImageEffect(path, mode));
    return Promise.all(promises);
  },
  
  /**
   * 合并多张图片为长图
   * @param {Array} imagePaths 图片路径数组
   * @returns {Promise} 返回合并后的图片路径
   */
  mergeToLongImage: function(imagePaths) {
    return new Promise((resolve, reject) => {
      if (!imagePaths || imagePaths.length === 0) {
        reject(new Error('没有可合并的图片'));
        return;
      }
      
      if (imagePaths.length === 1) {
        // 只有一张图片时直接返回
        resolve(imagePaths[0]);
        return;
      }
      
      console.log('开始合并图片，共' + imagePaths.length + '张');
      
      // 使用FileSystemManager确保文件存在
      const fs = wx.getFileSystemManager();
      const validPaths = [];
      
      // 验证所有图片路径是否有效
      for (let i = 0; i < imagePaths.length; i++) {
        try {
          const stat = fs.statSync(imagePaths[i]);
          if (stat && stat.size > 0) {
            validPaths.push(imagePaths[i]);
          } else {
            console.warn('图片文件无效:', imagePaths[i]);
          }
        } catch (err) {
          console.warn('图片文件不存在:', imagePaths[i], err);
        }
      }
      
      if (validPaths.length === 0) {
        reject(new Error('没有有效的图片文件'));
        return;
      }
      
      if (validPaths.length === 1) {
        // 只有一张有效图片时直接返回
        resolve(validPaths[0]);
        return;
      }
      
      // 创建临时文件路径
      const tempFilePath = `${wx.env.USER_DATA_PATH}/merged_${Date.now()}.jpg`;
      
      // 使用简单方法：将多张图片垂直拼接
      this._mergeImagesVertically(validPaths, tempFilePath)
        .then(finalPath => {
          console.log('合并图片成功:', finalPath);
          resolve(finalPath);
        })
        .catch(err => {
          console.error('合并图片失败:', err);
          // 失败时返回第一张有效图片
          resolve(validPaths[0]);
        });
    });
  },
  
  /**
   * 垂直拼接多张图片
   * @private
   * @param {Array} imagePaths 图片路径数组
   * @param {String} outputPath 输出路径
   * @returns {Promise} 返回合并后的图片路径
   */
  _mergeImagesVertically: function(imagePaths, outputPath) {
    return new Promise((resolve, reject) => {
      console.log('开始垂直拼接图片，共' + imagePaths.length + '张');
      
      // 获取所有图片的信息
      const getImageInfoPromises = imagePaths.map(path => {
        return new Promise((resolve, reject) => {
          wx.getImageInfo({
            src: path,
            success: res => {
              console.log('获取图片信息成功:', path, res.width, res.height);
              resolve({
                path: path,
                width: res.width,
                height: res.height
              });
            },
            fail: err => {
              console.error('获取图片信息失败:', path, err);
              reject(err);
            }
          });
        });
      });
      
      Promise.all(getImageInfoPromises)
        .then(imageInfos => {
          // 计算合并后的图片尺寸
          let totalHeight = 0;
          let maxWidth = 0;
          
          imageInfos.forEach(info => {
            totalHeight += info.height;
            maxWidth = Math.max(maxWidth, info.width);
          });
          
          console.log('合并后的图片尺寸:', maxWidth, totalHeight);
          
          // 创建canvas上下文
          const ctx = wx.createCanvasContext('longImageCanvas');
          
          // 设置canvas尺寸和背景
          ctx.fillStyle = '#FFFFFF';
          ctx.fillRect(0, 0, maxWidth, totalHeight);
          
          // 逐个绘制图片
          let currentY = 0;
          for (let i = 0; i < imageInfos.length; i++) {
            const info = imageInfos[i];
            // 居中绘制
            const x = (maxWidth - info.width) / 2;
            console.log('绘制图片:', i, x, currentY, info.width, info.height);
            ctx.drawImage(info.path, x, currentY, info.width, info.height);
            currentY += info.height;
          }
          
          // 完成绘制
          ctx.draw(true, () => {
            console.log('Canvas绘制完成，准备导出图片');
            
            // 延迟确保绘制完成
            setTimeout(() => {
              wx.canvasToTempFilePath({
                canvasId: 'longImageCanvas',
                x: 0,
                y: 0,
                width: maxWidth,
                height: totalHeight,
                destWidth: maxWidth,
                destHeight: totalHeight,
                fileType: 'jpg',
                quality: 0.8,
                success: res => {
                  console.log('导出长图成功:', res.tempFilePath);
                  resolve(res.tempFilePath);
                },
                fail: err => {
                  console.error('导出长图失败:', err);
                  // 失败时返回第一张图片
                  resolve(imagePaths[0]);
                }
              });
            }, 1000); // 给足够的时间让canvas完成绘制
          });
        })
        .catch(err => {
          console.error('处理图片信息失败:', err);
          // 出错时返回第一张图片
          resolve(imagePaths[0]);
        });
    });
  },
  
  /**
   * 生成PDF文件
   * @param {Array} imagePaths 图片路径数组
   * @param {String} title PDF标题
   * @returns {Promise} 返回PDF文件路径
   */
  generatePDF: function(imagePaths, title) {
    return new Promise((resolve, reject) => {
      if (!imagePaths || imagePaths.length === 0) {
        reject(new Error('没有可生成PDF的图片'));
        return;
      }
      
      console.log('开始生成PDF，图片数量:', imagePaths.length);
      
      // 首先合并所有图片为一张长图
      this.mergeToLongImage(imagePaths)
        .then(longImagePath => {
          console.log('已生成长图，准备转换为PDF:', longImagePath);
          
          // 确保PDF保存目录存在
          const fs = wx.getFileSystemManager();
          const saveDir = `${wx.env.USER_DATA_PATH}/pdf/`;
          try {
            fs.accessSync(saveDir);
          } catch (e) {
            console.log('创建PDF保存目录');
            fs.mkdirSync(saveDir, true);
          }
          
          // 创建PDF文件名，确保文件名有效
          const safeTitle = (title || '文档').replace(/[^\w\s]/gi, '');
          const fileName = `${safeTitle}_${Date.now()}.pdf`;
          const filePath = `${saveDir}${fileName}`;
          
          // 在微信小程序中，我们无法直接生成PDF
          // 这里我们将长图保存为PDF文件
          console.log('保存PDF文件到:', filePath);
          
          fs.copyFile({
            srcPath: longImagePath,
            destPath: filePath,
            success: () => {
              console.log('PDF文件生成成功:', filePath);
              
              // 将长图保存到相册
              wx.saveImageToPhotosAlbum({
                filePath: longImagePath,
                success: () => {
                  console.log('长图已保存到相册');
                  
                  // 返回PDF路径作为结果
                  resolve(filePath);
                },
                fail: (err) => {
                  console.error('保存到相册失败:', err);
                  // 即使保存到相册失败，仍然返回PDF路径
                  resolve(filePath);
                }
              });
            },
            fail: (err) => {
              console.error('复制文件失败:', err);
              reject(new Error('生成PDF失败: ' + err.errMsg));
            }
          });
        })
        .catch(err => {
          console.error('生成长图失败:', err);
          reject(new Error('生成PDF前的长图合并失败: ' + err.message));
        });
    });
  }
};

module.exports = ImageProcessor;